home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Shareware Grab Bag
/
Shareware Grab Bag.iso
/
090
/
cresid.arc
/
INTMAIN.C
< prev
next >
Wrap
Text File
|
1986-03-05
|
4KB
|
92 lines
/****************************************************************************
* INTMAIN.C -- main routine for a C interrupt handler
*
* This source file demonstrates how to make a routine resident. Notice
* that it calls int_init(), the interrupt initializtion function.
* Another routine, inttime(), is the actual interrupt handler.
*
* ---------------------------------------------------------------------------
* How to Create an Interrupt-Driven C Routine
*
* The theory behind interrupt driven code is easy to understand. The
* first thing to remember is that when an interrupt occurs, YOU CAN NOT
* BE SURE OF WHAT IS IN THE MACHINE REGISTERS. This is critical when
* hooking into hardware interrupts. Therefore, you must recreate your
* program environment every time your interrupt routine gets called.
*
* Lattice C code relies on certain things to always be available.
* The stack, heap, and static areas must ALWAYS be availble to the C
* code. For this reason, you cannot just keep a C program resident and
* expect it work. This source, along with CINT.ASM, show you the hows
* and whys of setting up a C environment.
*
* Step 1: Write your actual interrupt handler. It can do almost
* anything, depending on what type of interrupt you are hooking into.
* (Example: A routine that hooks into interrupt 24H MUST NOT call any
* DOS services except for services 01 - 12H. Doing so will destory the
* DOS stack.)
* When you compile this source, do so in the small model. DO NOT use
* the STD I/O routines (printf, scanf, etc.). Actually, you can try,
* but then you should disregard Step 2.
*
* Step 2: Recompile _MAIN.C in the S Model with the option -dTINY.
* What this does is create a new version of _main that does not open
* any of the STD I/O ports. (STDIN, STDOUT, STDERR, and in 3.00 STDPRT,
* and STDAUX.) Doing this will cut the size of the executable by at
* least 5K.
*
* Step 3: Modify CINT.ASM to suit your needs. This part is up to you.
* You may need to do what I did and hook into two interrupts. My other
* handler was written in assembler, and it just reinstalled my critical
* error vector. (A nasty trick, but one that was required.)
*
* Step 4: Link the .OBJ files. You will have to use the C.OBJ in the
* \LC\C directory. This allows us to EXE2BIN the resulting .EXE file.
* Include the required libraries (LC.LIB, and whatever), and ignore the
* "No stack" warning.
*
* Step 5: EXE2BIN the .EXE file. EXE2BIN seems to have problems with
* programs over 32K in size. Hopefully, you won't be getting this big.
* Rename the resulting .BIN file to a .COM file.
*
* Step 6: Run and/or debug the program, just like any other program.
* Just remeber to reboot the machine before you install your interrupt
* handler again.
*
* That's about it. You should now, with a little work, be able to write
* your own "SideKick" type program, or anything that requires itself to
* be patched into an interrupt and resident in memory.
*
* John Riley, Lattice Techincal Support
*
****************************************************************************/
#include "dos.h" /* Used for the REGS declaration */
extern unsigned _tsize; /* This is defined in C.ASM. It contains the size of
the entire program in paragraphs */
main()
{
union REGS out;
int_init(); /* Hook into the interrupt */
out.x.dx = _tsize; /* Setup for the intdos call */
out.x.ax = 0x3100; /* Terminate and stay resident call */
intdos(&out,&out);
}
/****************************************************************************
*
* INTTIME -- Interrupt handler
*
* This function can do anything it wants (within reason).
*
****************************************************************************/
inttime()
{
cprintf("Got here!!!\n");
return(0);
}